import base64 from '@/common/base64.js'
import msgHandler from '@/api/msgHandler/index.js'
import { MessageBox } from 'element-ui'

let timeoutObj = null
let serverTimeoutObj = null

/**
 * 当前时间戳加随机数生成taskId
 */
function generateTaskId() {
    return new Date().getTime() * 10000 + Math.random() * 10000
}


// state
const state = {
    webSocketUrl: 'ws://47.108.193.26:13088', // websocket地址
    webSocketObj: null, // websocket对象
    webSocketState: 0, // websocket状态
    loginLoading: false, // longinPage loading开关
    logined: 0, // 登陆状态 0表示未登陆 1表示已经登陆
}

// getters
const getters = {
    webSocketUrl: state => state.webSocketUrl,
    webSocketObj: state => state.webSocketObj,
    webSocketState: state => state.webSocketState,
    loginLoading: state => state.loginLoading,
    logined: state => state.logined,
}

// actions
const actions = {
    // 创建websocket
    createWebSocket({ dispatch, getters, commit }) {
        if (getters.webSocketObj) {
            commit('RESET_WEB_SOCKET')
        }
        commit('CREATE_WEB_SOCKET', dispatch)
    },
    // 向server发送一个心跳
    HeartBeatReq({ rootGetters, getters, commit }) {
        timeoutObj && clearTimeout(timeoutObj)
        serverTimeoutObj && clearTimeout(serverTimeoutObj)
        if (getters.webSocketObj.readyState === 1 && getters.logined) {
            // 发送一个心跳
            timeoutObj = setTimeout(() => {
                let msg = {
                    Id: 1001,
                    MsgType: 'HeartBeatReq',
                    AccessToken: rootGetters.token
                }
                commit('SEND_SOCK', msg)
                serverTimeoutObj = setTimeout(function () {
                    // 服务器返回超时
                    if (rootGetters.autoLogin) {
                        // 重新连接websocket
                        // createWebSocket()
                    }
                }, 5000)
            }, 5000)
        }
    },
    // server pc登陆 返回DeviceAuthRsp
    DeviceAuthReq({ rootGetters, commit }) {
        let ruleForm = rootGetters.loginInfo
        let msg = {
            'Id': 1010,
            'AccessToken': '',
            'MsgType': 'DeviceAuthReq',
            'Content': {
                'AuthType': 2,
                'Credential': base64.encode(ruleForm.name + ':' + ruleForm.pass)
            }
        }
        commit('SEND_SOCK', msg)
    },
    // 告诉server退出登陆 返回DeviceExitNotice
    AccountLogoutNotice({ rootGetters, commit }) {
        let msg = {
            Id: 3054,
            MsgType: 'AccountLogoutNotice',
            Content: {
                UnionId: Number(rootGetters.currentUser.UnionId),
                AccountType: 2
            },
            AccessToken: rootGetters.token
        }
        commit('SEND_SOCK', msg)

    },
    // 从sdk 获取微信列表 返回GetWeChatsRsp
    GetWeChatsReq({ rootGetters, commit }) {
        let msg = {
            MsgType: 'GetWeChatsReq',
            Content: {
                AccountType: rootGetters.currentUser.AccountType,
                UnionId: rootGetters.currentUser.UnionId
            }
        }
        commit('SEND_SOCK', msg)
    },
    // server 选择微信登陆 返回WeChatLoginNoticeResp
    WeChatLoginNotice({ rootGetters, commit }, wechats) {
        let msg = {
            'MsgType': 'WeChatLoginNotice',
            'Content': {
                SupplierId: rootGetters.currentUser.SupplierId,
                UnionId: rootGetters.currentUser.UnionId,
                AccountType: rootGetters.currentUser.AccountType,
                WeChats: wechats
            }
        }
        commit('SEND_SOCK', msg)
    },
    // =============================================================================
    // 以下是 wxtools页面相关的sdk
    // =============================================================================
    // sdk 获取微信的二维码 返回PullWeChatQrCodeTaskResultNotice
    PullWeChatQrCodeTask({ commit }, wechatId) {
        let msg = {
            'MsgType': 'PullWeChatQrCodeTask',
            'Content': {
                WeChatId: wechatId
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 手机重启|上传日志|清除微信视频缓存 返回TaskResultNotice
    PhoneActionTask({ commit }, command) {
        let content = {
            WeChatId: command.wechatId,
            // Imei: 2, // 备用，用wxid或imei来定位手机
            Action: command.action, // 指令
            // StrParam: 4, // 字符串参数，后续扩展用
            // IntParam: 5, // 整型参数，后续扩展用
            TaskId: generateTaskId().toString()
        }
        let msg = { 'MsgType': 'PhoneActionTask', 'Content': content }
        commit('SEND_SOCK', msg)
    },
    // sdk 获取好友申请列表 返回FriendAddReqListNotice
    PullFriendAddReqListTask({ commit }, wechatId) {
        let content = {
            WeChatId: wechatId, // 所属微信
            StartTime: 0, // 毫秒，0 则全部
            OnlyNew: false, // 只获取未读的请求
            GetAll: true // 获取所有的加好友请求信息，包括已经添加的
        }
        let msg = { 'MsgType': 'PullFriendAddReqListTask', 'Content': content }
        commit('SEND_SOCK', msg)
    },
    // sdk 接受好友请求 返回FriendAddNotice
    AcceptFriendAddRequestTask({ rootState, rootGetters, commit }, row) {
        let wechatId = rootGetters['currentWechats'][rootGetters['currentNavs'][rootState.route.name]]
        let msg = {
            MsgType: 'AcceptFriendAddRequestTask',
            Content: {
                WeChatId: wechatId, // 商家个人微信内部全局唯一识别码
                FriendId: row.FriendId, // 请求的好友微信内部全局唯一识别码
                Operation: 1, // 处理结果 0忽略 1接受 2拒绝
                Remark: row.Remark || '', // 其他备注信息
                // FriendNick: 7, // 好友的微信昵称 没用
                // ReplyMsg: 8,  // 拒绝时的回复消息
                // TaskId: 9, //任务Id
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 添加好友 返回TaskResultNotice
    AddFriendsTask({ rootGetters, dispatch, commit }, addFriendForm) {
        let content = {
            // IMEI: '', // 该值与WeChatId二选一, IMEI优先
            WeChatId: addFriendForm.wechatId, // 商家所属微信号
            Phones: addFriendForm.phones, // 要添加的手机号码，批量
            message: addFriendForm.message, // 发送的验证消息
            Remark: addFriendForm.memo, // 备注名
            TaskId: addFriendForm.taskId // 任务Id
        }
        let msg = { 'MsgType': 'AddFriendsTask', 'Content': content }
        commit('SEND_SOCK', msg)
        // 任务保存到nedb
        content.userId = rootGetters.userId
        content.result = '指令已发出'
        dispatch('nedb/AddOrUpdateAddFriends', content, { root: true })
    },
    // sdk 清理僵尸粉 返回PostFriendDetectCountNotice
    PostFriendDetectTask({ rootGetters, dispatch, commit }, clearForm) {
        let content = {
            WeChatId: clearForm.wechatId, // 微信id
            TaskId: generateTaskId().toString(), // 清粉任务ID
            // Message: 3, // 消息内容（当前发空名片，该字段暂时废弃）
            OnlyCheck: !clearForm.delete, // false 检测到立即删除，true 不删除，通知到服务端
            SkipHour: clearForm.time, // 跳过多少小时内有互动的好友（聊天，朋友圈互动,上次已检测等），缺省72小时
            Mode: clearForm.circle ? 6 : 1 // 1不检测朋友圈 6检测朋友圈
        }
        let msg = {
            MsgType: 'PostFriendDetectTask',
            Content: content
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 停止清理僵尸粉 返回TaskResultNotice
    PostStopFriendDetectTask({ dispatch, commit }, wechatId) {
        let content = {
            WeChatId: wechatId, // 微信id
            TaskId: generateTaskId().toString() // 清粉任务ID
        }
        let msg = {
            MsgType: 'PostStopFriendDetectTask',
            Content: content
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 查询联系人 返回 FindContactTaskResultNotice
    FindContactTask({ dispatch, commit }, message) {
        let content = {
            WeChatId: message.WeChatId, // 商家所属微信号
            Content: message.Content, // 查找的手机号，微信号，QQ号
        }
        let msg = {
            MsgType: 'FindContactTask',
            Content: content
        }
        commit('SEND_SOCK', msg)
        // 查询记录保存到本地数据库
        let doc = {}
        for (const key in content) {
            if (content.hasOwnProperty(key)) {
                doc[key] = content[key]
            }
        }
        doc.time = new Date().getTime()
        doc.result = 0
        dispatch('nedb/AddFindContactTask', doc, { root: true })
    },
    // server 获取自动任务的配置文件 返回AutoTaskDetailListResp
    AutoTaskDetailList({ rootGetters, commit }, wechatId) {
        let content = {
            cid: rootGetters.currentUser.SupplierId // 所属客户id  //登录下发下来的supplierid
        }
        let msg = { 'MsgType': 'AutoTaskDetailList', 'Content': content }
        commit('SEND_SOCK', msg)
    },
    // server 更新自动任务的配置文件 返回AutoTaskUpdateResp
    AutoTaskUpdate({ rootGetters, commit }, config) {
        let content = {
            cid: rootGetters.currentUser.SupplierId, // 所属客户id  //登录下发下来的supplierid
            wechatId: config.wechatId,
            auto_type: config.type, // 1001;// 自动抢红包   1002;// 自动通过好友请求  1003;// 自动通过群邀请链接请求
            state: config.state // 0是开启, 其他表示关闭
        }
        let msg = { 'MsgType': 'AutoTaskUpdate', 'Content': content }
        commit('SEND_SOCK', msg)
    },

    // =============================================================================
    // 以下是 friendCircle 页面相关的sdk
    // =============================================================================

    // sdk 获取某个微信的朋友圈 返回CirclePushNotice
    PullFriendCircleTask({ commit }, pullMsg) {
        let startTime = Math.floor(new Date().getTime() / 1000)
        let content = {
            WeChatId: pullMsg.wechatId, // 所属微信
            FriendId: pullMsg.friendId, // 获取好友的朋友圈
            StartTime: pullMsg.startTime ? pullMsg.startTime : startTime, // UTC秒，小于该时间，用于向下翻页
            Count: pullMsg.count ? pullMsg.count : 10 // 最多条数，缺省20条，传0则全部
            // RefTime: 5 // UTC秒，大于该时间，用于向上翻页
        }
        let msg = { MsgType: 'PullFriendCircleTask', Content: content }
        commit('SEND_SOCK', msg)
    },
    // sdk 获取指定朋友圈 返回CirclePushNotice
    TriggerCirclePushTask({ commit }, circle) {
        let content = {
            WeChatId: circle.WeChatId,
            CircleIds: [circle.CircleId]
        }
        let msg = { MsgType: 'TriggerCirclePushTask', Content: content }
        commit('SEND_SOCK', msg)
    },
    // sdk 删除指定朋友圈 返回TaskResultNotice
    DeleteSNSNewsTask({ dispatch, commit }, circle) {
        let content = {
            WeChatId: circle.WeChatId,
            CircleId: circle.CircleId,
            TaskId: generateTaskId().toString()
        }
        let msg = { 'MsgType': 'DeleteSNSNewsTask', 'Content': content }
        commit('SEND_SOCK', msg)
        let doc = {}
        for (const key in content) {
            if (content.hasOwnProperty(key)) {
                doc[key] = content[key]
            }
        }
        doc.MsgType = 'DeleteSNSNewsTask'
        dispatch('nedb/AddCircleTask', doc, { root: true })
    },
    // sdk 点赞|取消点赞 返回TaskResultNotice
    CircleLikeTask({ dispatch, commit }, circle) {
        let cancel = false
        if (circle.Likes) {
            for (const like of circle.Likes) {
                if (like.FriendId === circle.WeChatId) {
                    cancel = true
                    break
                }
            }
        }
        let content = {
            WeChatId: circle.WeChatId, // 所属微信
            CircleId: circle.CircleId, // 所属朋友圈
            IsCancel: cancel, // 是否取消点赞
            TaskId: generateTaskId().toString()
        }
        let msg = { 'MsgType': 'CircleLikeTask', 'Content': content }
        commit('SEND_SOCK', msg)
        let doc = {
            WeChatId: circle.WeChatId, // 所属微信
            CircleId: circle.CircleId, // 所属朋友圈
            IsCancel: cancel, // 是否取消点赞
            TaskId: content.TaskId,
            MsgType: 'CircleLikeTask',
        }
        if (circle.FriendId) {
            doc.FriendId = circle.FriendId
        }
        dispatch('nedb/AddCircleTask', doc, { root: true })
    },
    // sdk 获取朋友圈图片 返回CircleDetailNotice
    PullCircleDetailTask({ commit }, circle) {
        let msg = {
            'MsgType': 'PullCircleDetailTask',
            'Content': {
                WeChatId: circle.WeChatId,
                CircleId: circle.CircleId
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 删除评论 返回CircleCommentDeleteTaskResultNotice
    CircleCommentDeleteTask({ dispatch, commit }, circle) {
        let comment = circle.currentComment

        let content = {
            WeChatId: circle.WeChatId,
            CircleId: circle.CircleId,
            CommentId: comment.CommentId,
            PublishTime: comment.PublishTime,
            TaskId: generateTaskId().toString()
        }
        let msg = { 'MsgType': 'CircleCommentDeleteTask', 'Content': content }
        commit('SEND_SOCK', msg)

        // 保存到nedb
        let doc = {
            WeChatId: circle.WeChatId,
            CircleId: circle.CircleId,
            CommentId: comment.CommentId,
            PublishTime: comment.PublishTime,
            TaskId: content.TaskId,
            MsgType: 'CircleCommentDeleteTask',
            Comments: circle.Comments,
        }
        if (circle.FriendId) {
            doc.FriendId = circle.FriendId
        }
        dispatch('nedb/AddCircleTask', doc, { root: true })
    },
    // sdk 评论 返回circleCommentReplyTaskResultNotice
    CircleCommentReplyTask({ dispatch, commit }, circle) {
        let content = {
            WeChatId: circle.WeChatId, // 所属微信
            CircleId: circle.CircleId, // 所属朋友圈
            Content: circle.value, // 回复的内容
            TaskId: generateTaskId().toString(), // 本地的评论表数据id （重发需要传递）
            IsResend: false // 是否是重发 （手机端忽略）
        }
        // 回复好友的评论
        if (circle.currentComment) {
            content.ToWeChatId = circle.currentComment.FromWeChatId // 回复的好友
            content.ReplyCommentId = circle.currentComment.CommentId // 回复的评论id
        }
        let msg = { 'MsgType': 'CircleCommentReplyTask', 'Content': content }
        commit('SEND_SOCK', msg)

        // 保存到nedb
        let doc = {
            WeChatId: circle.WeChatId, // 所属微信
            CircleId: circle.CircleId, // 所属朋友圈
            Content: circle.value, // 回复的内容
            TaskId: content.TaskId, // 本地的评论表数据id （重发需要传递）
            IsResend: false, // 是否是重发 （手机端忽略）
            MsgType: 'CircleCommentReplyTask',
        }
        if (circle.FriendId) {
            doc.FriendId = circle.FriendId
        }
        if (circle.currentComment) {
            doc.ToWeChatId = circle.currentComment.FromWeChatId // 回复的好友
            doc.ReplyCommentId = circle.currentComment.CommentId // 回复的评论id
        }
        dispatch('nedb/AddCircleTask', doc, { root: true })
    },
    // sdk 发送朋友圈 返回PostSNSNewsTaskResultNotice
    PostSNSNewsTask({ dispatch, commit }, circle) {
        let content = {
            WeChatId: circle.WeChatId,
            Content: circle.Content,
            Attachment: circle.Attachment,
            Comment: circle.Comment,
            TaskId: generateTaskId().toString(),
            Visible: circle.Visible
        }
        let msg = { 'MsgType': 'PostSNSNewsTask', 'Content': content }
        commit('SEND_SOCK', msg)

        // 保存到nedb
        let doc = {}
        for (const key in content) {
            if (content.hasOwnProperty(key)) {
                doc[key] = content[key]
            }
        }
        doc.MsgType = 'PostSNSNewsTask'
        dispatch('nedb/AddCircleTask', doc, { root: true })
    },

    // =============================================================================
    // 以下是 群发 页面相关的sdk
    // =============================================================================

    // sdk 群发助手 返回TaskResultNotice
    WeChatGroupSendTask({ dispatch, commit }, message) {
        let content = {
            TaskId: generateTaskId().toString(), // 任务id
            FriendIds: message.FriendIds, // 目标人群id列表
            ContentType: message.ContentType, // 内容类型
            Content: message.Content, // 文字内容 或 图片列表
            WeChatId: message.WeChatId // 微信号id
        }
        let msg = { MsgType: 'WeChatGroupSendTask', Content: content }
        commit('SEND_SOCK', msg)
        // 任务保存到nedb数据库
        let doc = {}
        for (const key in content) {
            if (content.hasOwnProperty(key)) {
                doc[key] = content[key]
            }
        }
        doc.MsgType = 'WeChatGroupSendTask'
        dispatch('nedb/AddGroupSendTask2Nedb', doc, { root: true })
    },
    // server 定时任务 无返回
    AddTaskTimeInfo({ dispatch, rootGetters, commit }, message) {
        // private Integer tasktype;//（通用参数） 任务类型1群发消息2发朋友圈
        // private Integer state;// 状态1开启中0已完成
        // private String execute_time;//（通用参数） 执行时间
        // private Integer restype;// 资源类型(群发好友:0文字 1图片 ；朋友圈:0链接 2图片 3短视频)
        // private String content;//（通用参数） 内容
        // private String comment;// 针对发朋友圈
        // private Integer attachtype;// 附件类型
        // private String attachtcontent;// 附件内容
        // private String whoinvisible;// 不给谁看
        // private Date update_time;
        // private Date createTime;
        // private String wechatId;//（通用参数） 要执行的微信号
        // private String friendId;//（通用参数）好友微信ID
        // private List<String> wechatList;// 要群发的微信号
        let content = {}
        for (const key in message) {
            if (message.hasOwnProperty(key)) {
                content[key] = message[key]
            }
        }
        content.accountid = rootGetters.currentUser.UnionId

        // let content = {
        // accountid: rootGetters.currentUser.UnionId, // 登录的时候已经下发unionid
        // tasktype: message.tasktype, // 1PC群发消息,2PC发朋友圈,3删除好友,4删除群聊,5群发群消息,6按标签群发,7发朋友圈,8批量加好友
        // state: 1, // 状态1开启中0已完成
        // wechatId: message.wechatId, // 要执行的微信号
        // wechatList: message.wechatList, // 好友的微信号
        // execute_time: message.execute_time, // 执行时间
        // restype: message.restype, // 资源类型(群发好友:0文字 1图片；朋友圈:0链接 2图片 3短视频)
        // content: message.content, // 内容
        // }
        let msg = { MsgType: 'AddTaskTimeInfo', Content: content }
        commit('SEND_SOCK', msg)
    },
    // server 查询定时任务的结果 返回GetTaskInfoListResp
    GetTaskInfoList({ rootGetters, commit }, parameter) {
        let content = {
            accountid: rootGetters.currentUser.UnionId, // 登录的时候已经下发unionid
            pageSize: 100, // 每页多少条
            pageNo: 1// 当前第几页 从1开始
            // tasktype: '', // 非必传 1PC群发消息,2PC发朋友圈,3删除好友,4删除群聊,5群发群消息,6按标签群发,7发朋友圈,8批量加好友
            // state: 1 //非必传// 状态1开启中0已完成
        }
        let msg = { MsgType: 'GetTaskInfoList', Content: content }
        commit('SEND_SOCK', msg)
    },
    // server 批量加好友 返回 AutoFriendAddTaskResp
    AutoFriendAddTask({ rootGetters, commit }, content) {
        let msg = { MsgType: 'AutoFriendAddTask', Content: content }
        commit('SEND_SOCK', msg)
    },
    // server 获取加好友任务列表 返回 GetAutoFriendAddTaskListResp
    GetAutoFriendAddTaskList({ rootGetters, commit }) {
        let msg = {
            MsgType: 'GetAutoFriendAddTaskList',
            Content: {
                accountid: rootGetters.currentUser.UnionId,
                pageSize: 10000,
                pageNo: 1
            }
        }
        commit('SEND_SOCK', msg)
    },
    // server 查询号码 返回 GetPhoneNumberListResp
    GetPhoneNumberList({ rootGetters, commit }, content = {}) {
        if (rootGetters['currentWechats']['searchPhones']) {
            content.wechatid = rootGetters['currentWechats']['searchPhones']
        }
        let msg = {
            MsgType: 'GetPhoneNumberList',
            Content: content
        }
        commit('SEND_SOCK', msg)
    },

    // =============================================================================
    // 以下是 conversation页面相关的sdk
    // =============================================================================

    // sdk 推送当前会话列表 返回ConversationPushNotice
    TriggerConversationPushTask({ rootGetters, commit }, wechat) {
        let wechatId = wechat ? wechat : rootGetters['conversation/currentWeChatId']
        let msg = {
            'MsgType': 'TriggerConversationPushTask',
            'Content': { WeChatId: wechatId, StartTime: 0 }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 从手机获取历史消息 返回HistoryMsgPushNotice
    TriggerHistoryMsgPushTask({ rootGetters, commit }, message) {
        let msg = {
            MsgType: 'TriggerHistoryMsgPushTask',
            Content: {
                WeChatId: message.wechatId,
                FriendId: message.friendId, // 好友id, 置空表示全部好友
                StartTime: message.startTime, // 开始同步的消息时间，0表示全部,UTC毫秒
                EndTime: message.endTime // 结束同步的消息时间，0表示到当前时间为止
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 推送指定微信的通讯录 返回FriendPushNotice
    TriggerFriendPushTask({ rootGetters, commit }) {
        let wechatId = rootGetters['conversation/currentWeChatId']
        let msg = {
            // Id: 1080,
            MsgType: 'TriggerFriendPushTask',
            Content: { WeChatId: wechatId }
        }
        commit('SEND_SOCK', msg)
    },
    // // 根据wechatId 获取通讯录
    // TriggerFriendPushTaskById({ commit }, wechatId) {
    //     let msg = {
    //         MsgType: 'TriggerFriendPushTask',
    //         Content: { WeChatId: wechatId }
    //     }
    //     commit('SEND_SOCK', msg)
    // },
    // sdk 获取指定好友的详情 返回 FriendAddNotice
    // sdk 获取群成员的详情 返回 ChatRoomMembersNotice
    RequestContactsInfoTask({ commit }, message) {
        let msg = {
            MsgType: 'RequestContactsInfoTask',
            Content: {
                WeChatId: message.wechatId,
                Contact: message.friendId
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 获取指定群聊的详情
    // 返回1.群的信息ChatRoomAddNotice
    // 返回2.群成员信息ChatRoomMembersNotice
    RequestChatRoomInfoTask({ commit }, message) {
        let msg = {
            MsgType: 'RequestChatRoomInfoTask',
            Content: {
                WeChatId: message.wechatId,
                ChatRoomId: message.friendId,
                Flag: 1, // Flag=1:推送成员信息（ChatRoomMembersNotice)
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 推送群聊列表 推送陌生人列表
    // 返回群聊列表 ChatroomPushNotice
    // 返回陌生人列表 ChatRoomMembersNotice
    TriggerChatroomPushTask({ commit }, wechatId) {
        let msg = {
            MsgType: 'TriggerChatroomPushTask',
            Content: {
                WeChatId: wechatId, // 商家所属微信号
                Flag: 1 // Flag = 1:不推送成员信息（ChatRoomMembersNotice)
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 设置消息为已读 返回无
    TriggerMessageReadTask({ commit }, message) {
        let msg = {
            MsgType: 'TriggerMessageReadTask',
            Content: {
                WeChatId: message.WeChatId,
                FriendId: message.FriendId,
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 发送聊天消息 返回 TalkToFriendTaskResultNotice
    TalkToFriendTask({ commit, dispatch }, message) {
        let sendTime = new Date().getTime()
        let content = {
            WeChatId: message.WeChatId, // 所属微信号
            FriendId: message.FriendId, // 发送给那个好友
            ContentType: message.ContentType, // 发送消息类型 Text Picture Voice Video Link File NameCard WeApp
            Content: base64.encode(message.Content), // 发送消息内容 文本，文件url，链接json，名片wxid
            MsgId: generateTaskId().toString(), // 发送给手机端的时候需要赋值，用于TalkToFriendTaskResultNotice中
            // Remark: '', // 其他备注信息，群聊@别人
            // SendTime: 5, // 发送时间 老的业务，未使用
            // IsResend: 6, // 是否是重发 老的业务，未使用
            // ResendTime: 7, // 重发时间 老的业务，未使用
        }
        if (message.Remark) {
            content.Remark = message.Remark
        }
        let msg = { 'MsgType': 'TalkToFriendTask', 'Content': content }
        // 发送消息
        commit('SEND_SOCK', msg)
        // 消息保存本地nedb chats
        let doc = {}
        // 保存在本地数据库的时候 把@X带上
        for (const key in content) {
            if (content.hasOwnProperty(key)) {
                doc[key] = content[key]
            }
        }
        doc.CreateTime = sendTime.toString()
        doc.IsSend = true
        dispatch('nedb/AddChats', doc, { root: true })
        // 发送成功之后才能将消息保存本地nedb conversation
        // dispatch('nedb/UpdateOrAddConversationsByTalk', doc, { root: true })
    },
    // sdk 修改备注信息 返回TaskResultNotice
    ModifyFriendMemoTask({ commit, dispatch }, content) {
        content.TaskId = generateTaskId().toString()
        let msg = {
            MsgType: 'ModifyFriendMemoTask',
            Content: content
        }
        // 发送消息
        commit('SEND_SOCK', msg)
        // 操作保存本地nedb memoTask
        dispatch('nedb/AddMemoTask', content, { root: true })
    },
    // sdk 添加或删除标签
    // 新建标签返回 ContactLabelAddNotice
    // 删除标签返回 ContactLabelDelNotice
    // 打标签结果 TaskResultNotice
    ContactLabelTask({ commit, dispatch }, message) {
        let content = {
            WeChatId: message.WeChatId, //string 商家所属微信号
            LabelId: message.LabelId || 0, //int32 标签id，0则新建标签（如存在同名标签则会失败）
            taskId: generateTaskId().toString(), //int64
            // LabelName: message.LabelName || '', //string 标签名 id!=0 会设置为该标签名
            // AddList: message.AddList || '', //string 新增的wxid，用,分隔
            // DelList: message.DelList || '', //string 删除的wxid，用,分隔
        }
        if (message.LabelName) {
            content.LabelName = message.LabelName
        }
        if (message.AddList) {
            content.AddList = message.AddList
        }
        if (message.DelList) {
            content.DelList = message.DelList
        }
        let msg = {
            MsgType: 'ContactLabelTask',
            Content: content
        }
        // 发送消息
        commit('SEND_SOCK', msg)
        let doc = {}
        for (const key in content) {
            if (content.hasOwnProperty(key)) {
                doc[key] = content[key]
            }
        }
        doc.TaskId = content.taskId
        // 操作保存本地nedb memoTask
        dispatch('nedb/AddMemoTask', doc, { root: true })
    },
    // sdk 群管理 返回TaskResultNotice
    ChatRoomActionTask({ commit, dispatch }, message) {
        // content.TaskId = taskId.toString()
        // RoomName = 0; // 改群名 content=群昵称
        // ModifyPublicNoti = 1;// 改公告 content=公告内容
        // AddMember = 2; // 拉人 content=微信id，用','分隔
        // KickMember = 3; // 踢人 content=微信id，用','分隔
        // RoomShowName = 4; // 修改群内显示名 content=显示名
        // AddToPhonebook = 5; // 加入通讯录 IntValue=0 取消，IntValue=1 加入
        // NewMsgNoti = 6; // 新消息通知 IntValue=0 (消息免打扰 )，IntValue=1 通知
        // ExitRoom = 7;// 退群
        // CreateRoom = 8;// 建群 content=初始成员微信id，用','分隔
        // ViewAllMember = 9; // 查看所有群成员
        // TransferOwner = 10; // 群主转让
        // SetVerify = 11; // 设置群聊邀请确认 IntValue=0 关闭，IntValue=1 打开
        // AddManager = 12; // 设置群管理员
        // DelManager = 13; // 删除群管理员
        let content = {
            WeChatId: message.WeChatId, //string 商家所属微信号
            // ChatRoomId: message.ChatRoomId, //string 群聊id
            Action: message.Action, //EnumChatRoomAction 指令
            // Content: 4, //string 指令内容
            // IntValue: 5, //int32
            taskId: generateTaskId().toString(), //int64
        }
        if (message.ChatRoomId) {
            content.ChatRoomId = message.ChatRoomId
        }
        if (message.IntValue) {
            content.IntValue = message.IntValue
        }
        if (message.Content) {
            content.Content = message.Content
        }
        let msg = {
            MsgType: 'ChatRoomActionTask',
            Content: content
        }
        // 发送消息
        commit('SEND_SOCK', msg)

        let doc = {}
        for (const key in content) {
            if (content.hasOwnProperty(key)) {
                doc[key] = content[key]
            }
        }
        doc.TaskId = content.taskId
        // 操作保存本地nedb chatRoomTask
        dispatch('nedb/AddChatRoomTask', doc, { root: true })
    },
    // sdk 获取群二维码 返回PullChatRoomQrCodeTaskResultNotice
    PullChatRoomQrCodeTask({ commit }, message) {
        let msg = {
            MsgType: 'PullChatRoomQrCodeTask',
            Content: {
                WeChatId: message.WeChatId, // 商家所属微信号
                ChatRoomId: message.UserName, // 群聊id
                taskId: generateTaskId().toString()
            }
        }
        commit('SEND_SOCK', msg)
    },
    // sdk 添加群成员到通讯录 返回TaskResultNotice
    AddFriendInChatRoomTask({ commit, dispatch }, message) {
        let msg = {
            MsgType: 'AddFriendInChatRoomTask',
            Content: {
                WeChatId: message.WeChatId, // 商家个人微信内部全局唯一识别码
                ChatroomId: message.ChatroomId, // 所在的群聊id
                FriendId: message.FriendId, // 请求加好友微信内部全局唯一识别码
                Message: message.Message, // 招呼语
                Remark: message.Remark, // 备注信息
                TaskId: generateTaskId().toString(), //任务Id
            }
        }
        commit('SEND_SOCK', msg)
        let doc = msg.Content
        // 操作保存本地nedb chatRoomTask
        dispatch('nedb/AddChatRoomTask', doc, { root: true })
    },
    // sdk 发红包 返回TaskResultNotice
    SendLuckyMoneyTask({ commit, dispatch }, message) {
        let sendTime = new Date().getTime()
        let taskId = sendTime * 10000 + Math.random() * 10000
        let content = {
            WeChatId: message.WeChatId, // 微信唯一Id
            FriendId: message.FriendId, // 聊天好友微信唯一id
            Money: message.Money, // 钱数，单位：分，最多20000
            Number: message.Number, // 红包个数，缺省1个
            Passwd: message.Passwd, // 密码，6位，纯数字
            Wish: message.Wish, // 祝福语
            TaskId: taskId, // 任务id
        }
        let msg = {
            'MsgType': 'SendLuckyMoneyTask',
            'Content': content
        }
        // 发送消息
        commit('SEND_SOCK', msg)
        // 消息保存本地nedb chats
        let doc = {}
        // 按收到的红包格式创建一个本地消息
        let redContent = {
            "Title": message.Wish,
            "Key": "",
            "InvalidTime": '',
        }
        // 发红包的自定义的字段
        redContent.Money = message.Money
        doc.Content = base64.encode(JSON.stringify(redContent))
        doc.ContentType = 'LuckyMoney'
        doc.FriendId = message.FriendId
        doc.WeChatId = message.WeChatId
        doc.MsgId = taskId.toString()
        // doc.msgSvrId = friendId
        doc.CreateTime = sendTime.toString()
        doc.IsSend = true
        dispatch('nedb/AddChats', doc, { root: true })

        // 插入luncMoney, 好友领红包的时候用到
        // doc.opened = 0
        // doc.InvalidTime = ''
        // doc.Key = ''
        // doc.Title = content.Wish
        // doc.SendId = ''
        //     this.$nedb.luckMoney.insert(
        //         doc,
        //         (err, newDoc) => { // Callback is optional
        //             if (err) return
        //         })
    },
    // sdk 转账 返回TaskResultNotice
    RemittanceTask({ commit, dispatch }, message) {
        let sendTime = new Date().getTime()
        let content = {
            WeChatId: message.WeChatId, // 微信唯一Id
            FriendId: message.FriendId, // 聊天好友微信唯一id
            Money: message.Money, // 钱数，单位：分
            Passwd: message.Passwd, // 密码，6位，纯数字
            Memo: message.Memo, // 留言
            TaskId: generateTaskId().toString(), // 任务id
        }
        let msg = {
            'MsgType': 'RemittanceTask',
            'Content': content
        }
        // 发送消息
        commit('SEND_SOCK', msg)

        // 消息保存本地nedb chats
        let doc = {}
        // 按收到的红包格式创建一个本地消息
        let redContent = {
            "Title": message.Memo,
            "Feedesc": '￥' + message.Money / 100,
            "Key": "",
            "PaySubType": 1,
            "InvalidTime": ''
        }
        // 转账的自定义的字段
        doc.Content = base64.encode(JSON.stringify(redContent))
        doc.ContentType = 'MoneyTrans'
        doc.FriendId = message.FriendId
        doc.WeChatId = message.WeChatId
        doc.MsgId = content.TaskId
        // doc.msgSvrId = friendId
        doc.CreateTime = sendTime.toString()
        doc.IsSend = true
        dispatch('nedb/AddChats', doc, { root: true })

        // 插入luncMoney, 好友领红包的时候用到
        // doc.opened = 0
        // doc.InvalidTime = ''
        // doc.Key = ''
        // doc.Title = content.Wish
        // doc.SendId = ''
        //     this.$nedb.luckMoney.insert(
        //         doc,
        //         (err, newDoc) => { // Callback is optional
        //             if (err) return
        //         })
    },
    // sdk 获取消息详情
    // 如果成功返回 RequestTalkDetailTaskResultNotice
    // 如果失败返回 TaskResultNotice
    RequestTalkDetailTask({ commit, dispatch }, message) {
        let content = {
            MsgId: message.MsgId, // 全局消息id
            WeChatId: message.WeChatId, // 微信唯一Id
            FriendId: message.FriendId, // 聊天好友微信唯一id
            MsgSvrId: message.msgSvrId ? message.msgSvrId : '', // 微信设备上消息唯一id(FriendTalkNotice中上传)
            Md5: message.Content.Md5 ? message.Content.Md5 : '', // 图片或视频md5(FriendTalkNotice中上传)
            GetOriginal: true, // 获取原图（获取接收到的图片消息的原图时置true，其他false）
        }
        let msg = {
            'MsgType': 'RequestTalkDetailTask',
            'Content': content
        }
        // 发送消息
        commit('SEND_SOCK', msg)
    },
    // sdk 删除好友 返回FriendDelNotice
    DeleteFriendTask({ commit, dispatch }, message) {
        let content = {
            WeChatId: message.WeChatId, // 商家所属微信号
            FriendId: message.FriendId, // 要删除的微信号
            TaskId: generateTaskId().toString(), //任务Id
        }
        let msg = {
            'MsgType': 'DeleteFriendTask',
            'Content': content
        }
        // 发送消息
        commit('SEND_SOCK', msg)
    },
    // sdk 消息撤回 返回TaskResultNotice
    RevokeMessageTask({ commit, dispatch }, chat) {
        let content = {
            MsgId: chat.msgSvrId, // 这里传MsgSvrId，传long类型，js中传字符串
            WeChatId: chat.WeChatId,
            FriendId: chat.FriendId,
            TaskId: chat.msgSvrId
        }
        let msg = {
            'MsgType': 'RevokeMessageTask',
            'Content': content
        }
        // 发送消息
        commit('SEND_SOCK', msg)
    },
    // sdk 同意加入群聊 返回TaskResultNotice
    AgreeJoinChatRoomTask({ commit, dispatch }, message) {
        let msg = {
            MsgType: 'AgreeJoinChatRoomTask',
            Content: {
                WeChatId: message.WeChatId, // 商家个人微信内部全局唯一识别码
                Talker: message.Talker, // 邀请者
                MsgSvrId: message.MsgSvrId, // 邀请消息的msgSvrId
                MsgContent: message.MsgContent, // 回传邀请信息的内容（json）
                taskId: generateTaskId().toString()
            }
        }
        // 发送消息
        commit('SEND_SOCK', msg)
    },
    // sdk 打开红包或转账 返回TakeMoneyTaskResultNotice
    TakeLuckyMoneyTask({ commit, dispatch }, message) {
        let msg = {
            MsgType: 'TakeLuckyMoneyTask',
            Content: {
                WeChatId: message.WeChatId, //微信唯一Id
                FriendId: message.FriendId, //聊天好友微信唯一id
                MsgSvrId: message.MsgSvrId, //全局消息id
                MsgKey: message.MsgKey, // 消息内容中的Key
                TaskId: generateTaskId().toString(), //
            }
        }
        // 发送消息
        commit('SEND_SOCK', msg)
        // 添加到数据库
        let doc = {}
        for (const key in msg.Content) {
            if (msg.Content.hasOwnProperty(key)) {
                doc[key] = msg.Content[key]
            }
        }
        dispatch('nedb/InsertLuckMoney', doc, { root: true })
    },
    // sdk 查询红包 返回QueryHbDetailTaskResultNotice
    QueryHbDetailTask({ commit, dispatch }, message) {
        let msg = {
            MsgType: 'QueryHbDetailTask',
            Content: {
                WeChatId: message.WeChatId, // 所属微信号
                HbUrl: message.HbUrl, // 红包key
            }
        }
        // 发送消息
        commit('SEND_SOCK', msg)
        // 添加到数据库
        // let doc = {}
        // for (const key in msg.Content) {
        //     if (msg.Content.hasOwnProperty(key)) {
        //         doc[key] = msg.Content[key]
        //     }
        // }
        // dispatch('nedb/InsertLuckMoney', doc, { root: true })
    },
    // sdk 推送公共号列表 返回BizContactPushNotice
    TriggerBizContactPushTask({ commit, rootGetters }) {
        let msg = {
            MsgType: 'TriggerBizContactPushTask',
            Content: {
                WeChatId: rootGetters['conversation/currentWeChatId'], //微信唯一Id
            }
        }
        commit('SEND_SOCK', msg)
    },
    // server 获取公共话术 返回GetCommonTermsResp
    GetCommonTerms({ rootGetters, commit }) {
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            let msg = { MsgType: 'GetCommonTerms', Content: { id: uionId, name: 'pc' } }
            commit('SEND_SOCK', msg)
        }
    },
    // 获取任务列表 GetTodoResp
    GetTodoList({rootGetters,commit}){
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            let msg = { MsgType: 'GetTodo', Content: { userId: uionId } }
            commit('SEND_SOCK', msg)
        }
    },
    // 获取任务明细列表
    GetTaskDetailManager({rootGetters,commit}){
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            let msg = { MsgType: 'GetTaskDetailManager', Content: { responsibleUserId: uionId } }
            commit('SEND_SOCK', msg)
        }
    },
    // 回传 
    GetTodoDetail({rootGetters,commit},obj){
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            let msg = { MsgType: 'CreateTaskDatil', Content: { id:obj.id,userId: uionId } }
            // console.log(JSON.stringify(msg))
            commit('SEND_SOCK', msg)
        }

    },
    // 已完成 CloseTodoResp
    CloseTodo({rootGetters,commit},obj){
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            let msg = { MsgType: 'CloseTodo', Content: { id:obj.id,userId: uionId } }
            // console.log(JSON.stringify(msg))
            commit('SEND_SOCK', msg)
        }

    }, 
    // 字典 GetAllDictResp
    GetAllDictList({rootGetters,commit}){
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            let msg = { MsgType: 'GetAllDict', Content: { id: uionId } }
            commit('SEND_SOCK', msg)
        }

    },
    // 保存 录入工单 SaveTaskDatilResp
    SaveTaskDatil({rootGetters,commit},obj){
        let uionId = Number(rootGetters.currentUser.UnionId)
        obj.responsibleUserId=uionId
        if (uionId) {
            let msg = { MsgType: 'SaveTaskDatil', Content: obj }
            
            commit('SEND_SOCK', msg)
        }

    },
    CloseTaskDetail({rootGetters,commit},obj){
        let uionId = Number(rootGetters.currentUser.UnionId)
        obj.responsibleUserId=uionId
        if (uionId) {
            let msg = { MsgType: 'CloseTaskDetail', Content: obj }
            console.log(JSON.stringify(msg))
            commit('SEND_SOCK', msg)
        }

    },
    // 修改工单录入
    UpdataTaskDatil({rootGetters,commit},obj){
        let uionId = Number(rootGetters.currentUser.UnionId)
        obj.responsibleUserId=uionId
        if (uionId) {
            let msg = { MsgType: 'UpdateTaskDetail', Content: obj }
            console.log(JSON.stringify(msg))
            
            commit('SEND_SOCK', msg)
        }

    },
    //查询消息列表 GetNoticeListResp
    GetNoticeList({rootGetters,commit}){
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            let msg = { MsgType: 'GetNoticeList', Content: { userId: uionId } }
            // console.log(JSON.stringify(msg))
            commit('SEND_SOCK', msg)
        }
    },
    // 一键已读
    CloseNoticeList({rootGetters,commit},list){
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            console.log(list)
            let msg = { MsgType: 'CloseNoticeList', Content: list }
            console.log(JSON.stringify(msg))
            commit('SEND_SOCK', msg)
        }
    },
    // server 获取公共标签 返回GetCommonTagsResp
    GetCommonTags({ rootGetters, commit }) {
        let uionId = Number(rootGetters.currentUser.UnionId)
        if (uionId) {
            let msg = { MsgType: 'GetCommonTags', Content: { id: uionId, name: 'pc' } }
            commit('SEND_SOCK', msg)
        }
    },
    // server 从服务端获取备注信息 返回GetWechatFriendDetailResp 已经弃用
    GetWechatFriendDetail({ rootGetters, commit }, friend) {
        let content = {
            cid: Number(rootGetters.SupplierId),
            wechatid: friend.WeChatId,
            friendid: friend.FriendId
        }
        let msg = { MsgType: 'GetWechatFriendDetail', Content: content }
        // commit('SEND_SOCK', msg)
    },
}

// mutations
const mutations = {
    // 设置websocketUrl
    SET_WEBSOCKET_URL(state, newWS) {
        state.webSocketUrl = newWS
    },
    // 设置登陆状态
    SET_LOGINED: (state, logined) => {
        state.logined = logined
    },
    // 创建websocket
    CREATE_WEB_SOCKET(state, dispatch) {
        state.webSocketObj = new WebSocket(state.webSocketUrl)

        state.webSocketObj.onopen = () => {
            // websocket连接成功
        }

        state.webSocketObj.onmessage = (event) => {
            // 发送心跳
            dispatch('HeartBeatReq')
            // 处理收到的数据
            msgHandler(event)
        }

        state.webSocketObj.onerror = (e) => {
            // websocket报错
            // 如果账号在别的地方登陆 || 或者token过期就不再重连了 || 主动退出 都不再重连
            // if (store.getters.autoLogin) {
            //     if (linkTimes > 4) {
            //         // 重连连续失败3次，不再重连
            //         store.commit("SET_AUTO_LOGIN", 0)
            //         // 弹出提示框
            //         MessageBox.alert(
            //             'websocket连接断开，请检查网络！',
            //             '错误提示',
            //             {
            //                 type: 'error',
            //                 showClose: false,
            //                 confirmButtonText: '确定并退出',
            //                 callback: () => {
            //                     window.location.reload()
            //                 }
            //             }
            //         )
            //     } else {
            //         setTimeout(function () {
            //             createWebSocket()
            //         }, 5000)
            //     }
            // } else {
            //     linkTimes = 0
            // }
        }

        state.webSocketObj.onclose = () => {
            // websocket关闭
            // 正常退出不提示websocket关闭
            if (state.token) {
                MessageBox.alert('websocket已经关闭，请重新登陆', '提示', {
                    confirmButtonText: '确定',
                    callback: action => {
                        dispatch('AccountLogoutNotice')
                        if (process.env.VUE_APP_CURRENTMODE === 'electron') {
                            const { ipcRenderer } = window.require('electron')
                            ipcRenderer.send('operations', 'logout')
                        } else {
                            window.location.reload()
                        }
                    }
                });
            }
        }
    },
    // 重置websocket
    RESET_WEB_SOCKET(state) {
        state.webSocketObj = null
    },
    // 发送消息
    SEND_SOCK(state, agentData) {
        // 1 表示连接已建立，可以进行通信。
        // 2 连接正在进行关闭握手，即将关闭
        // 3 连接已经关闭或者根本没有建立。
        // 0 正在建立连接，还没有完成 默认值
        switch (state.webSocketObj.readyState) {
            case 1:
                state.webSocketObj.send(JSON.stringify(agentData))
                break;
            case 2:
            case 3:
                // 连接已经关闭，请刷新后再试
                // alert('连接已经关闭，请刷新后再试')
                break;
            default:
                // 正在建立连接，还没有完成 默认值
                setTimeout(() => {
                    state.webSocketObj.send(JSON.stringify(agentData))
                }, 1000);
                break;
        }
    },
    // 设置登陆页面的loading
    SET_LOGIN_LOADING(state, flag) {
        state.loginLoading = flag
    }
}

export default {
    namespaced: true,
    state,
    getters,
    actions,
    mutations
}
